home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / plotting / imagetoo / imagetl1.lha / Imagetool / HDF / dfp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-09-20  |  10.4 KB  |  353 lines
  1. /*****************************************************************************
  2. * 
  3. *              NCSA HDF version 3.10
  4. *                July 1, 1990
  5. *
  6. * NCSA HDF Version 3.10 source code and documentation are in the public
  7. * domain.  Specifically, we give to the public domain all rights for future
  8. * licensing of the source code, all resale rights, and all publishing rights.
  9. * 
  10. * We ask, but do not require, that the following message be included in all
  11. * derived works:
  12. * 
  13. * Portions developed at the National Center for Supercomputing Applications at
  14. * the University of Illinois at Urbana-Champaign.
  15. * 
  16. * THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
  17. * SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
  18. * WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
  19. * 
  20. *****************************************************************************/
  21.  
  22. #ifdef RCSID
  23. static char RcsId[] = "@(#)$Revision: 3.1 $";
  24. #endif
  25. /*
  26. $Header: /pita/work/HDF/dev/RCS/src/dfp.c,v 3.1 90/07/02 11:52:10 clow beta $
  27.  
  28. $Log:    dfp.c,v $
  29.  * Revision 3.1  90/07/02  11:52:10  clow
  30.  * some cosmetic modifications
  31.  * 
  32.  * Revision 3.0  90/02/02  20:30:53  clow
  33.  * *** empty log message ***
  34.  * 
  35. */
  36.  
  37. /*-----------------------------------------------------------------------------
  38.  * File:    dfp.c
  39.  * Purpose: read and write palettes
  40.  * Invokes: df.c
  41.  * Contents: 
  42.  *  DFPgetpal: retrieve next palette
  43.  *  DFPputpal: write palette to file
  44.  *  DFPaddpal: add palette to file
  45.  *  DFPnpals: number of palettes in HDF file
  46.  *  DFPreadref: get palette with this reference number next
  47.  *  DFPwriteref: put palette with this reference number next
  48.  *  DFPrestart: forget info about last file accessed - restart from beginning
  49.  *  DFPlastref: return reference number of last element read or written
  50.  *  DFPIopen: open/reopen file
  51.  *---------------------------------------------------------------------------*/
  52.  
  53. #include "df.h"
  54.  
  55. static uint16 Readref=0;
  56. static uint16 Writeref=0;
  57. static uint16 Refset=0;        /* Ref of palette to get next */
  58. static uint16 Lastref = 0;    /* Last ref read/written */
  59.  
  60. static char Lastfile[DF_MAXFNLEN]; /* last file opened */
  61.  
  62. #ifndef VMS
  63. DF *DFPIopen();
  64. #else /*VMS*/
  65. DF *_DFPIopen();
  66. #endif
  67.  
  68.  
  69. /*-----------------------------------------------------------------------------
  70.  * Name:    DFPgetpal
  71.  * Purpose: get next palette from file
  72.  * Inputs:  filename: name of HDF file
  73.  *          palette: 768 byte space to read palette into
  74.  * Returns: 0 on success, -1 on failure with DFerror set
  75.  *          palette in pal
  76.  * Users:   HDF HLL users, utilities, other routines
  77.  * Invokes: DFPIopen, DFIerr, DFclose, DFgetelement
  78.  *---------------------------------------------------------------------------*/
  79.  
  80. int DFPgetpal(filename, palette)
  81. char *filename;
  82. char *palette;
  83. {
  84.     DF *dfile;
  85.     int cdd, ret;
  86.     DFdle *dlep;
  87.  
  88.     DFerror = DFE_NOERROR;
  89.  
  90.     if (!palette) {
  91.         DFerror = DFE_BADPTR;
  92.         return(-1);
  93.     }
  94.     dfile = DFPIopen(filename, DFACC_READ);
  95.     if (dfile == NULL) return(-1);
  96.  
  97.     if (Refset)
  98.         ret = DFIfind(dfile, DFTAG_IP8, Refset, 1,(uint16) 0, (uint16) 0,
  99.               &dlep, &cdd);
  100.     else
  101.         ret = DFIfind(dfile,DFTAG_IP8,0, !Readref, DFTAG_IP8,Readref,
  102.               &dlep,&cdd);
  103.  
  104.     Refset = 0;
  105.     if (ret<0) return(DFIerr(dfile)); /* on error, close file and return -1 */
  106.  
  107.     Readref = dlep->dd[cdd].ref; /* ref of element to read */
  108.  
  109.         /* read palette */
  110.     if (DFgetelement(dfile, DFTAG_IP8, Readref, palette)<0)
  111.             return(DFIerr(dfile));
  112.  
  113.     Lastref = Readref;
  114.  
  115.     return(DFclose(dfile));
  116. }
  117.  
  118.  
  119. /*-----------------------------------------------------------------------------
  120.  * Name:    DFPputpal
  121.  * Purpose: Write palette to file
  122.  * Inputs:  filename: name of HDF file
  123.  *          palette: palette to be written to file
  124.  *          overwrite: if 1, overwrite last palette read or written
  125.  *                     if 0, write it as a fresh palette
  126.  *          filemode: if "a", append palette to file
  127.  *                    if "w", create new file
  128.  * Returns: 0 on success, -1 on failure with DFerror set
  129.  * Users:   HDF users, programmers, utilities
  130.  * Invokes: DFPIopen, DFclose, DFputelement, DFIerr
  131.  * Remarks: To overwrite, the filename must be the same as for the previous
  132.  *          call
  133.  *---------------------------------------------------------------------------*/
  134.  
  135. int DFPputpal(filename, palette, overwrite, filemode)
  136. char *filename;
  137. char *palette;
  138. int overwrite;
  139. char *filemode;
  140. {
  141.     DF *dfile;
  142.  
  143.     DFerror = DFE_NOERROR;
  144.  
  145.     if (!palette) {
  146.         DFerror = DFE_BADPTR;
  147.         return(-1);
  148.     }
  149.  
  150.     if (overwrite && strcmp(filename, Lastfile)) {
  151.         DFerror = DFE_BADCALL;
  152.         return(-1);
  153.     }
  154.  
  155.     dfile = DFPIopen(filename, (*filemode=='w') ? DFACC_CREATE : DFACC_WRITE);
  156.     if (dfile==NULL) return(-1);
  157.  
  158.         /* if we want to overwrite, Lastref is the ref to write.  If not, if
  159.             Writeref is set, we use that ref.  If not we get a fresh ref. The
  160.             ref to write is placed in Lastref */
  161.     if (!overwrite) Lastref = Writeref ? Writeref : DFnewref(dfile);
  162.     if (Lastref == 0) return(-1);
  163.  
  164.     Writeref = 0;           /* don't know ref to write after this */
  165.  
  166.         /* write out palette */
  167.     if (DFputelement(dfile, DFTAG_IP8, Lastref, palette, (int32) 768)<0)
  168.             return(DFIerr(dfile));
  169.  
  170.     return(DFclose(dfile));
  171. }
  172.  
  173.  
  174. /*-----------------------------------------------------------------------------
  175.  * Name:    DFPaddpal
  176.  * Purpose: Add palette to file
  177.  * Inputs:  filename: name of HDF file
  178.  *          palette: palette to be written to file
  179.  * Returns: 0 on success, -1 on failure with DFerror set
  180.  * Users:   HDF users, programmers, utilities
  181.  * Invokes: DFPputpal
  182.  *---------------------------------------------------------------------------*/
  183.  
  184. int DFPaddpal(filename, palette)
  185. char *filename;
  186. char *palette;
  187. {
  188.  
  189.     return(DFPputpal(filename, palette, 0, "a"));
  190. }
  191.  
  192.  
  193. /*-----------------------------------------------------------------------------
  194.  * Name:    DFPnpals
  195.  * Purpose: How many palettes are present in this file?
  196.  * Inputs:  filename: name of HDF file
  197.  * Returns: number of palettes on success, -1 on failure with DFerror set
  198.  * Users:   HDF programmers, other routines and utilities
  199.  * Invokes: DFPIopen, DFclose, DFnumber
  200.  *---------------------------------------------------------------------------*/
  201.  
  202. int DFPnpals(filename)
  203. char *filename;
  204. {
  205.     DF *dfile;
  206.     int npals=0;
  207.  
  208.     DFerror = DFE_NOERROR;
  209.  
  210.     /* should use reopen if same file as last time - more efficient */
  211.     dfile = DFPIopen(filename, DFACC_READ);
  212.     if (dfile==NULL) return(-1);
  213.  
  214.     npals = DFnumber(dfile, DFTAG_IP8);    /* count number of IPs */
  215.     if (npals<0) return(DFIerr(dfile));
  216.  
  217.     if (DFclose(dfile)<0) return(-1);
  218.     return(npals);
  219. }
  220.  
  221.  
  222. /*-----------------------------------------------------------------------------
  223.  * Name:    DFPreadref
  224.  * Purpose: Set ref of palette to get next
  225.  * Inputs:  filename: file to which this applies
  226.  *          ref: reference number of next get
  227.  * Returns: 0 on success, -1 on failure
  228.  * Users:   HDF programmers, other routines and utilities
  229.  * Invokes: DFPIopen, DFIfind, DFclose
  230.  * Remarks: checks if palette with this ref exists
  231.  *---------------------------------------------------------------------------*/
  232.  
  233. int DFPreadref(filename, ref)
  234. char *filename;
  235. uint16 ref;
  236. {
  237.     DF *dfile;
  238.     int cdd;
  239.     DFdle *dlep;
  240.  
  241.     DFerror = DFE_NOERROR;
  242.  
  243.     dfile = DFPIopen(filename, DFACC_READ);
  244.     if (dfile==NULL) return(-1);
  245.  
  246.     if (DFIfind(dfile, DFTAG_IP8, ref, 1, 0, 0, &dlep, &cdd)<0)
  247.         return(DFIerr(dfile));
  248.  
  249.     Refset = ref;
  250.     return(DFclose(dfile));
  251. }
  252.  
  253.  
  254. /*-----------------------------------------------------------------------------
  255.  * Name:    DFPwriteref
  256.  * Purpose: Set ref of palette to put next
  257.  * Inputs:  filename: file to which this applies
  258.  *          ref: reference number of next put
  259.  * Returns: 0 on success, -1 on failure
  260.  * Users:   HDF programmers, other routines and utilities
  261.  * Invokes: none
  262.  *---------------------------------------------------------------------------*/
  263.  
  264. /* shut lint up */
  265. /* ARGSUSED */
  266. int DFPwriteref(filename, ref)
  267. char *filename;
  268. uint16 ref;
  269. {
  270.     DFerror = DFE_NOERROR;
  271.  
  272.     Writeref = ref;
  273.     return(0);
  274. }
  275.  
  276.  
  277.  
  278. /*-----------------------------------------------------------------------------
  279.  * Name:    DFPrestart
  280.  * Purpose: Do not remember info about file - get again from first palette
  281.  * Inputs:  none
  282.  * Returns: 0 on success
  283.  * Users:   HDF programmers
  284.  * Remarks: Just reset Lastfile to NULL
  285.  *---------------------------------------------------------------------------*/
  286.  
  287. int DFPrestart()
  288. {
  289.  
  290.     Lastfile[0] = '\0';
  291.     return(0);
  292. }
  293.  
  294.  
  295. /*-----------------------------------------------------------------------------
  296.  * Name:    DFPlastref
  297.  * Purpose: Return last ref written or read
  298.  * Inputs:  none
  299.  * Globals: Lastref
  300.  * Returns: ref on success, -1 on error with DFerror set
  301.  * Users:   HDF users, utilities, other routines
  302.  * Invokes: none
  303.  * Method:  return Lastref
  304.  * Remarks: none
  305.  *---------------------------------------------------------------------------*/
  306.  
  307. int DFPlastref()
  308. {
  309.  
  310.     return(Lastref);
  311. }
  312.  
  313.  
  314.  
  315. /******************************************************************************/
  316. /*----------------------- Internal routines ---------------------------------*/
  317. /******************************************************************************/
  318.  
  319.  
  320. /*-----------------------------------------------------------------------------
  321.  * Name:    DFPIopen
  322.  * Purpose: open or reopen a file
  323.  * Inputs:  filename: name of file to open
  324.  *          access : access mode
  325.  * Returns: file pointer on success, NULL on failure with DFerror set
  326.  * Users:   HDF systems programmers, other DFP routines
  327.  * Invokes: DFopen
  328.  * Remarks: This is a hook for someday providing more efficient ways to
  329.  *          reopen a file, to avoid re-reading all the headers
  330.  *---------------------------------------------------------------------------*/
  331.  
  332. DF *DFPIopen(filename, access)
  333. char *filename;
  334. int access;
  335. {
  336.  
  337.     DF *dfile;
  338.  
  339.         /* use reopen if same file as last time - more efficient */
  340.     if (strncmp(Lastfile,filename,DF_MAXFNLEN) || (access==DFACC_CREATE)) {
  341.                                     /* treat create as different file */
  342.         if (!(dfile = DFopen(filename, access, -1))) return(NULL);
  343.         Refset = 0;         /* no ref to get set for this file */
  344.         Readref = 0;
  345.     }
  346.     else
  347.         if (!(dfile = DFopen(filename, access, -1))) return(NULL);
  348.  
  349.     DFIstrncpy(Lastfile, filename, DF_MAXFNLEN);
  350.         /* remember filename, so reopen may be used next time if same file */
  351.     return(dfile);
  352. }
  353.